/*
 * Copyright (C) 2009, Edmundo Albuquerque de Souza e Silva.
 *
 * This file may be distributed under the terms of the Q Public License
 * as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE.QPL included in the packaging of this file.
 *
 * THIS FILE IS PROVIDED AS IS WITH NO WARRANTY OF ANY KIND, INCLUDING
 * THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,
 * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */

package net.sf.fmj.media.codec.audio.alaw;

import net.sf.fmj.utility.UnsignedUtils;

/**
 *  Turns 16-bit linear PCM values into 8-bit A-law bytes.
 * Adapted from code by Marc Sweetgall at http://www.codeproject.com/csharp/g711audio.asp
 */
public class ALawEncoderUtil
{
    public static final int MAX = 0x7fff; //maximum that can be held in 15 bits

    /**
     *  An array where the index is the 16-bit PCM input, and the value is
     *  the a-law result.
     */
    private static byte[] pcmToALawMap;

    static
    {
        pcmToALawMap = new byte[65536];
        for (int i = Short.MIN_VALUE; i <= Short.MAX_VALUE; i++)
            pcmToALawMap[UnsignedUtils.uShortToInt((short) i)] = encode(i);
    }

    /**
     *  Encode one a-law byte from a 16-bit signed integer. Internal use only.
     *  
     *  @param pcm A 16-bit signed pcm value
     *  @return A a-law encoded byte
     */
    private static byte encode(int pcm)
    {
        //Get the sign bit.  Shift it for later use without further modification
        int sign = (pcm & 0x8000) >> 8;
        //If the number is negative, make it positive (now it's a magnitude)
        if (sign != 0)
            pcm = -pcm;
        //The magnitude must fit in 15 bits to avoid overflow
        if (pcm > MAX) pcm = MAX;

        /* Finding the "exponent"
         * Bits:
         * 1 2 3 4 5 6 7 8 9 A B C D E F G
         * S 7 6 5 4 3 2 1 0 0 0 0 0 0 0 0
         * We want to find where the first 1 after the sign bit is.
         * We take the corresponding value from the second row as the exponent value.
         * (i.e. if first 1 at position 7 -> exponent = 2)
         * The exponent is 0 if the 1 is not found in bits 2 through 8.
         * This means the exponent is 0 even if the "first 1" doesn't exist.
         */
        int exponent = 7;
        //Move to the right and decrement exponent until we hit the 1 or the exponent hits 0
        for (int expMask = 0x4000; (pcm & expMask) == 0 && exponent>0; exponent--, expMask >>= 1) { }

        /* The last part - the "mantissa"
         * We need to take the four bits after the 1 we just found.
         * To get it, we shift 0x0f :
         * 1 2 3 4 5 6 7 8 9 A B C D E F G
         * S 0 0 0 0 0 1 . . . . . . . . . (say that exponent is 2)
         * . . . . . . . . . . . . 1 1 1 1
         * We shift it 5 times for an exponent of two, meaning
         * we will shift our four bits (exponent + 3) bits.
         * For convenience, we will actually just shift the number, then AND with 0x0f. 
         * 
         * NOTE: If the exponent is 0:
         * 1 2 3 4 5 6 7 8 9 A B C D E F G
         * S 0 0 0 0 0 0 0 Z Y X W V U T S (we know nothing about bit 9)
         * . . . . . . . . . . . . 1 1 1 1
         * We want to get ZYXW, which means a shift of 4 instead of 3
         */
        int mantissa = (pcm >> ((exponent == 0) ? 4 : (exponent + 3))) & 0x0f;

        //The a-law byte bit arrangement is SEEEMMMM (Sign, Exponent, and Mantissa.)
        byte alaw = (byte)(sign | exponent << 4 | mantissa);

        //Last is to flip every other bit, and the sign bit (0xD5 = 1101 0101)
        return (byte)(alaw^0xD5);
    }

    /**
     *  Encode a pcm value into a a-law byte
     *  
     *  @param pcm A 16-bit pcm value
     *  @return A a-law encoded byte
     */
    public static byte aLawEncode(int pcm)
    {
        return pcmToALawMap[UnsignedUtils.uShortToInt((short) (pcm & 0xffff))];
    }

    /**
     *  Encode a pcm value into a a-law byte
     *  
     *  @param pcm A 16-bit pcm value
     *  @return A a-law encoded byte
     */
    public static byte aLawEncode(short pcm)
    {
        return pcmToALawMap[UnsignedUtils.uShortToInt(pcm)];
    }

//    /**
//     *  Encode an array of pcm values
//     *  
//     *  @param data An array of 16-bit pcm values
//     *  @parem encoded An array to be filled with a-law bytes containing the results. must be same size as data.
//     */
//    public static void aLawEncode(int[] data, byte[] encoded)
//    {
//        int size = data.length;
//        //byte[] encoded = new byte[size];
//        for (int i = 0; i < size; i++)
//            encoded[i] = aLawEncode(data[i]);
//        //return encoded;
//    }
//
//    /**
//     *  Encode an array of pcm values
//     *  
//     *  @param data An array of 16-bit pcm values
//     *  @parem encoded An array to be filled with a-law bytes containing the results. must be same size as data.
//     */
//    public static void aLawEncode(short[] data, byte[] encoded)
//    {
//        int size = data.length;
//        //byte[] encoded = new byte[size];
//        for (int i = 0; i < size; i++)
//            encoded[i] = aLawEncode(data[i]);
//        //return encoded;
//    }
//
//    /**
//     *  Encode an array of pcm values
//     *  
//     *  @param data An array of bytes in Little-Endian format
//     *  @return An array of a-law bytes containing the results
//     */
//    public static byte[] aLawEncode(byte[] data)
//    {
//        int size = data.length / 2;
//        byte[] encoded = new byte[size];
//        for (int i = 0; i < size; i++)
//            encoded[i] = aLawEncode((data[2 * i + 1] << 8) | data[2 * i]);
//        return encoded;
//    }

    /**
     *  Encode an array of pcm values into a pre-allocated target array
     *  
     *  @param data An array of bytes in Little-Endian format
     *  @param target A pre-allocated array to receive the A-law bytes.  This array must be at least half the size of the source.
     */
    public static void aLawEncode(boolean bigEndian, byte[] data, int offset, int length, byte[] target)
    {
    	if (bigEndian)
    		aLawEncodeBigEndian(data, offset, length, target);
    	else
    		aLawEncodeLittleEndian(data, offset, length, target);
     }

    public static void aLawEncodeLittleEndian(byte[] data, int offset, int length, byte[] target)
    {
        int size = length / 2;
        for (int i = 0; i < size; i++)
            target[i] = aLawEncode(((data[offset + 2 * i + 1] & 0xff) << 8) | (data[offset + 2 * i]) & 0xff);
    }

    public static void aLawEncodeBigEndian(byte[] data, int offset, int length, byte[] target)
    {
        int size = length / 2;
        for (int i = 0; i < size; i++)
            target[i] = aLawEncode(((data[offset + 2 * i + 1]) & 0xff) | ((data[offset + 2 * i] & 0xff) << 8));
    }
}
